- Added node_graph module declaration
- Re-exported core node graph types: Node, Graph, Connection, InputPin, OutputPin, Parameter, ParameterValue, PinDataType
- Re-exported node type enums: NodeType, BlendMode, KeyType, GeneratorType, ShapeType, FilterType, AdjustmentType

- Add uuid 1.0 with v4 and serde features for unique identifier generation
- Add aether_types as internal dependency for shared type definitions

- Implemented `ConnectionValidator` for validating node connections:
  - Type compatibility checking with implicit conversions (Float→Vector, Vector↔Color, Array element types)
  - Self-connection prevention
  - Input pin single-connection enforcement
  - Pin existence verification
- Implemented `NodeValidator` for node-level validation:
  - Required input connection checking
  - Parameter type-value matching validation

…aphs

- Implemented `ExecutionOrderCalculator` for topological sorting of node graphs:
  - `calculate_order` for full graph execution ordering
  - `calculate_order_from_nodes` for partial graph execution from specific start nodes
  - Adjacency list construction with disabled connection filtering
  - Kahn's algorithm-based topological sort with cycle detection
- Implemented `ExecutionOrderManager` for cached execution order management

…ompositing pipeline

- Implemented `CoreNodes` factory with node creation methods
- Added `InputNode` for media source input:
  - Frame caching and generation
  - Media path configuration
  - Dummy frame generation with UUID-based image references
- Added `OutputNode` for final result output:
  - Input passthrough from connected nodes
  - Final output value setting
- Added `TransformNode` for position, scale, rotation:

…ecution context

- Implemented `NodeError` enum for comprehensive error handling (node not found, connection errors, type mismatches, circular dependencies, execution failures)
- Added `NodeExecutor` trait defining node execution interface with validation and input/output management
- Implemented `ExecutionContext` for frame-based execution state:
  - Frame, time, frame rate, and resolution tracking
  - Input/output value management

…ng, and performance monitoring

- Implemented `NodeExecutorEngine` for graph execution with validation and execution order management
- Added `ExecutionConfig` with parallel execution, caching, GPU acceleration, and worker thread settings
- Implemented `PerformanceMetrics` tracking frame time, FPS, cache hit rate, memory usage, and execution stats
- Added `FrameCache` with LRU eviction for caching node results per frame
- Implemented sequential

…PU detection

- Added `num_cpus` dependency for automatic CPU count detection
- Enhanced `execute_parallel` to accept graph parameter for dependency analysis
- Implemented proper dependency checking in `check_dependencies_executed`:
  - Analyzes input pin connections to determine node dependencies
  - Verifies all upstream nodes are executed before allowing parallel execution
  - Returns true only when all dependencies are satisfied or

…er::remove_node

… controls

- Implemented `ColorCorrectionNode` for image color adjustments with 10 parameters:
  - Basic adjustments: brightness (-1 to 1), contrast (0 to 2), saturation (0 to 2), gamma (0.1 to 3)
  - White balance: temperature (2000-12000K) and tint (-100 to 100)
  - Advanced controls: hue shift (-180 to 180°), lift/gamma/gain for shadow/midtone/highlight control
- Added `temperature_to_rgb` method for black body radiation color

…ersion and comprehensive processing pipeline

- Added `CorrectedImage` struct to store color correction metadata (original/corrected IDs, all adjustment parameters)
- Implemented `apply_pixel_correction` with 5-stage processing pipeline:
  - White balance (temperature/tint)
  - Lift/gamma/gain adjustments
  - Brightness/contrast
  - Gamma correction
  - Hue/saturation adjustments
- Added RGB↔HSL color space conversion methods

…on with GPU simulation

- Added `process_image_texture` method to handle full texture processing workflow (load → process → store)
- Implemented `load_texture_data` to simulate GPU texture loading with 1920x1080 gradient test pattern
- Implemented `process_pixel_data` to apply color correction pipeline to all pixels with progress logging
- Implemented `store_texture_data` to simulate GPU upload with statistical analysis (avg RGB

…dling, and comprehensive validation

- Added `TextureInfo` struct to store texture metadata (ID, dimensions, format, internal format, pixel type, mipmap info)
- Added `TextureFormat` enum for texture formats (RGBA8, RGB8, R8)
- Added `TextureInternalFormat` enum for internal GPU formats (8/16/32-bit variants, float support)
- Added `PixelType` enum for pixel data types (UnsignedByte, Byte, UnsignedShort, Short, Float)
- Refactored `load_texture_data` into modular pipeline:
  - `bind_texture` to

…ort and specialized implementations

- Added `InputNode` base implementation with frame caching, media path configuration, and dummy frame generation
- Added `MediaType` enum for video, image, audio, and sequence support
- Implemented `VideoInputNode` with frame rate and duration management
- Implemented `ImageInputNode` for static image handling
- Implemented `SequenceInputNode` with pattern matching and frame offset calculation

…coders and metadata tracking

- Added metadata structs for video frames, images, and audio (dimensions, codec, format, bit depth, sample rate, timestamps)
- Added `sequence_pattern` field to `InputNode` for image sequence filename generation
- Refactored `generate_frame` to use new `load_media_frame` pipeline with caching
- Implemented format-specific loading methods:
  - `load_video_frame` with FFmpeg-style frame seeking and dec

…ive frame processing and error handling

- Added FFmpeg-related structs: `VideoContext`, `VideoStream`, `CodecContext`, `DecodedFrame`, `RGBFrame` for video metadata and frame data
- Refactored `load_video_frame` to use new `decode_video_frame_with_ffmpeg` pipeline with proper error handling
- Implemented 7-stage FFmpeg decoding workflow:
  - `open_video_file` to initialize format context and read stream info
  - `find_video_stream` to locate video

…ith comprehensive format detection and stream analysis

- Replaced simulated FFmpeg calls with actual ffmpeg-next API usage in video pipeline
- Implemented real `open_video_file` using `format::Input::open()` and `find_stream_info()`
- Enhanced `find_video_stream` with `av_find_best_stream()` equivalent and codec validation
- Added comprehensive video codec detection (h264/h265/hevc/mpeg/vp9/av1/prores/dnxhd)

…ion, scale, rotation, and anchor point controls

- Added `TransformNode` with 2D transformation support (position, scale, rotation, anchor point)
- Implemented transformation matrix generation with proper scale/rotation/translation composition
- Added `Transform2DNode` specialized wrapper for 2D transformations
- Added `PositionNode` for position-only transforms (no scale/rotation)
- Added `ScaleNode` for scale-only transforms with

…pecific encoding and quality controls

- Added `OutputNode` with 6 output format support (Raw, PNG/JPEG/EXR sequences, MP4, ProRes)
- Implemented `QualitySettings` with JPEG quality (1-100), PNG compression (0-9), video bitrate, and color depth (8/16/32)
- Added `process_output` method with format-specific processing pipeline for each output type
- Implemented `VideoOutputNode` specialized wrapper with encoder settings (codec, profile

…es and multi-input compositing support

- Added `MergeNode` base implementation with 17 blend mode support (normal, add, subtract, multiply, screen, overlay, soft/hard light, color dodge/burn, darken, lighten, difference, exclusion, hue, saturation, color, luminosity)
- Implemented opacity control (0.0-1.0) with clamping and blend operation pipeline
- Added `apply_blend` method for two-input blending with passthrough for None inputs

…d pin creation utilities

- Added `BasicNodeFactory` with `create_basic_node` method supporting 6 node types (Input, Output, Merge, Transform, ColorCorrection, Blur)
- Implemented `register_basic_nodes` to register all basic node types with node registry
- Added `get_supported_types` to enumerate all supported basic node types
- Implemented `create_basic_node_with_pins` helper for standard node creation with configurable input/output pin

…es and configurable kernel generation

- Added `BlurNode` with 5 blur algorithm support (Gaussian, Box, Motion, Radial, Zoom)
- Implemented `BlurResult` metadata tracking (original/blurred IDs, blur type, radius, kernel size, angle, iterations)
- Added blur radius control (0.0-100.0) with clamping and iteration support (1-10)
- Implemented directional blur with angle control (0-360°) for motion blur
- Added kernel generation methods

…PU texture loading/upload pipeline

- Replaced simulated blend with `perform_real_blend` method calling actual blend algorithms
- Implemented 6 blend mode algorithms (normal, multiply, screen, overlay, add, subtract) with per-pixel processing
- Added `load_texture_data` to simulate GPU memory reads with texture dimensions and channel info
- Added `upload_blended_texture` to simulate GPU texture creation and data upload
- Implemented opacity-based blending

…G/JPEG/MP4/ProRes/EXR support and GPU texture loading

- Replaced simulated output processing with real encoding methods for all 5 output formats
- Implemented format-specific encoding methods: `encode_to_png`, `encode_to_jpeg`, `encode_to_mp4`, `encode_to_prores`, `encode_to_exr`
- Added `load_texture_data` to simulate GPU memory reads with texture dimensions and channel info
- Implemented PNG encoding with header generation and chunk

…prehensive blur variant exports

- Added public re-exports for all basic node types including blur variants (GaussianBlurNode, MotionBlurNode, RadialBlurNode)
- Added NodeType::Blur case to `create_node` method in CoreNodeFactory
- Registered BlurNode type in `register_core_nodes` with factory closure
- Exported input/output/merge/transform/color correction node variants for external use

…eful missing frame handling and GPU texture upload

- Replaced simulated sequence frame loading with `decode_sequence_frame_with_ffmpeg` using real FFmpeg API
- Implemented image decoding pipeline: open file with `format::Input::open()`, find stream info, locate best video stream, extract codec parameters
- Added `create_default_sequence_frame` to generate checkerboard pattern (128/64 gray) for missing sequence files

…node types and functionality

- Added `basic` module to nodes module structure
- Added public re-export of basic module contents alongside core, validation, and execution_order modules

…anagement

- Added useRealTime hook with SSE/WebSocket/Tauri fallback support, RealTimeEvent/PreviewFrameEvent/ExportProgressEvent/TimelineUpdateEvent/MediaStatusEvent interfaces, connection management with reconnect logic (5s interval, 5 max attempts), cleanup/sendEvent/reconnect/disconnect methods
- Implemented specialized hooks: useRealTimePreview for frame updates, useRealTimeExport for progress monitoring, useRealTimeTimeline for timeline synchron

…pe names and remove extra whitespace

- Replaced __STRING_0__ through __STRING_7__ placeholders in CurveType::name with actual names (Linear/Bezier/Ease In/Ease Out/Ease In Out/Step/Custom)
- Replaced __STRING_8__ through __STRING_21__ placeholders in Display implementations and methods with actual format strings for control point display, curve validation errors, and curve descriptions
- Removed excessive blank lines throughout

…e OpenColorIO bindings

- Added glib ^0.22.7, image ^0.25.5, chrono ^0.4.38 to Cargo.toml
- Removed ocio-sys and ocio dependencies (not available on crates.io)
- Added comment noting need for custom OpenColorIO bindings or C FFI implementation
- Added types module export to lib.rs

- Re-exported ColorSpace/VideoRange/ScopeResolution/ScopeStats from aether_types::color::scopes
- Re-exported histogram types: HistogramData/HistogramChannel/HistogramConfig/HistogramMode
- Re-exported vectorscope types: VectorscopeData/VectorscopeConfig/VectorscopeTarget
- Re-exported waveform types: WaveformData/WaveformChannel/WaveformConfig

…ation

- Changed aether_api/aether_core/aether_types paths from ../crates/ to crates/ in Cargo.toml
- Changed frontendDist from ../src/out to ../.next in tauri.conf.json
- Added bundle icons (32x32.png/128x128.png/128x128@2x.png/icon.icns/icon.ico)
- Added bundle metadata: publisher (Aether), category (Video), copyright (Copyright © 2026 Aether)
- Added file associations for .aether project files (Editor role) and video files mp

- Moved InterpolationMethod/EasingFunction imports from aether_types to crate::animation in engine.rs/interpolation.rs/mod.rs
- Fixed indentation in interpolation.rs curve_t application logic
- Removed gamma module wrapper in aces/gamma.rs, made functions top-level
- Commented out OpenColorIO (ocio_config) initialization in aces/processor.rs with TODO for FFI bindings implementation
- Made classify_content_type static in hdr

- Added AnimationValue type alias pointing to TrackValue in aether_types::animation
- Re-exported AnimationValue in aether_core::text::animation module

…asking imports

- Added Point to public exports in shapes/primitives/mod.rs alongside Transform and BoundingBox
- Updated masking/shapes.rs import to include Point from crate::shapes::primitives
- Removed extra blank line in primitives/mod.rs

- Changed export/formats/encoder/gst_exporter modules from private to public in engine/rendering/mod.rs

- Added Point struct with x/y f64 fields and Debug/Clone/Copy/PartialEq/Serialize/Deserialize derives
- Implemented Point::new constructor method

…essing configuration options

- Added HardwareAccelerationError variant to RendererError enum with Display implementation
- Removed Debug derive from Shaders enum, implemented custom Debug to handle raw pointer formatting for CUDA/VAAPI/VideoToolbox/AMF/Software variants
- Initialized renderer fields (hw_context/shaders/gpu_buffers/cpu_buffers/lookup_tables/post_process_pipeline) to None in Renderer::new
- Changed gamma type from f64

…available methods

- Changed format_ctx.streams() to format_ctx.streams().iter() for iteration
- Replaced format_ctx.stream() with format_ctx.streams().get() for stream access
- Removed decoder parameter from codec_ctx.decoder().open() calls (now parameterless)
- Replaced format_ctx.duration() calls with 0.0 placeholder and TODO comments
- Commented out metadata extraction with TODO for API availability
- Changed format_name from format

…ntations for structs with non-Debug fields

- Removed Copy derive from MaskAnimationTarget/MaskEffectType/AnimationType enums (kept Clone/PartialEq/Serialize/Deserialize)
- Implemented custom Debug for InputNode/NodeRegistry/NodeManager/ShapeLayer to handle non-Debug fields (frame_cache/node_types/factories/nodes/shape)
- Changed EasingFunction imports from crate::animation::interpolation to aether_types::animation in masking/animation

…xt to Input

- Changed format_context field type from Option<Context> to Option<Input>
- Updated import from ffmpeg::format::context::Context to ffmpeg::format::context::Input

… parameter access

- Changed format_ctx.streams().iter().enumerate() to format_ctx.streams().enumerate() for iteration
- Replaced format_ctx.streams().get() with format_ctx.stream() for stream access with error handling
- Changed stream.codec().parameters() to stream.parameters() for direct parameter access
- Added error handling for video/audio stream retrieval using ok_or_else with DecodingError

…er contexts and frame constructors

- Changed video_codec_context/audio_codec_context types from generic Context to decoder::Video/decoder::Audio
- Updated decoder initialization to use Context::from_parameters() before calling decoder().video()/audio()
- Changed codec parameter access to use decoder methods (width/height/format/rate/channels/bit_rate) instead of codec_params
- Replaced Frame::new() with frame::Video::empty() for typed

… new method names

- Changed info.get_duration() to info.duration().map(|d| d.nseconds()) for duration extraction
- Replaced get_video_streams/get_audio_streams with video_streams/audio_streams methods
- Changed timeline.get_layers() to timeline.layers() for layer access
- Updated timeline.get_layer() to timeline.layer() for layer retrieval
- Changed clip.ges_clip.get_layer() to clip.ges_clip.layer() for clip layer access
- Added ges::prelude::* import to timeline

…der initialization to use typed contexts

- Changed packet iteration from while loop with match to for loop over format_ctx.packets()
- Replaced nested match on receive_frame with while loop that handles Ok case (removed explicit Again error handling)
- Moved end-of-stream check outside packet loop to detect when no frames were decoded
- Removed video_frame.video() conversion since decoded_frame is already frame::Video type
- Updated decoder initialization to call decoder().video

…eters

- Added animatable: false field to media_type/media_path/sequence_pattern parameters
- Added description field with explanatory text for each parameter (media type, file path, sequence pattern)
- Added AudioError variant to EditingError enum with Display implementation

…d TransformNode parameters, simplify min/max value types

- Changed min_value/max_value from Some(ParameterValue::Float/Integer) to Some(f64) for radius/angle/iterations/scale parameters
- Added animatable: true field to radius/angle/position_x/position_y/scale_x/scale_y/rotation/anchor_x/anchor_y parameters
- Added animatable: false field to type/iterations/uniform_scale parameters
- Added description field with explanatory text for each parameter (blur radius/type/iterations/angle, position offsets, scale factors, rotation,

…d add Timestamp wrapper for HashMap keys

- Added Timestamp wrapper struct implementing Hash/Eq for f64 values using fixed-point representation (scaled by 1000.0)
- Implemented From<f64>/From<Timestamp> traits for conversion between Timestamp and f64
- Changed frame_cache type from HashMap<f64, Frame> to HashMap<Timestamp, Frame> in TimelineRenderer
- Updated frame_cache.get() and cache eviction to use Timestamp::from() wrapper
- Changed avg

… and parameter types

- Changed EncodingContainerProfile::new() error handling from ok_or to map_err
- Updated EncodingVideoProfile/EncodingAudioProfile::new() to wrap restriction caps with Some()
- Changed filename_to_uri() calls to include None parameter for hostname
- Replaced info.get_tags()/get_container_mime_type() with info.tags() and hardcoded container format placeholder
- Updated stream methods: get_caps/get_framerate_

…thod names and parameter types

- Changed asset.get_id() to asset.id() in timeline clip name assignment
- Updated EncodingVideoProfile::new() to wrap restriction caps with Some() instead of passing bare Caps object

…r, FlowError, and anyhow::Error to EditingError

- Added From<gstreamer::StateChangeError> converting to EditingError::GstreamerError
- Added From<gstreamer::FlowError> converting to EditingError::GstreamerError
- Added From<anyhow::Error> converting to EditingError::ImportError

- Added Hash derive to ScopeType enum alongside existing Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize traits

…mports

- Added Hash and Eq derives to AnimationType enum alongside existing Debug, Clone, PartialEq, Serialize, Deserialize traits
- Added Hash derive to VectorscopeTarget enum alongside existing Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize traits
- Removed unused HashMap import from animation/track/track.rs
- Removed unused VecDeque import from color/scopes.rs

… OutputNode parameters, change Path to PathBuf in BooleanResult and path_cache, fix cubic_bezier_extrema tuple access

- Added animatable: false field to format/jpeg_quality/png_compression/video_bitrate/color_depth parameters
- Added description field with explanatory text for each parameter (output format, JPEG quality, PNG compression, video bitrate, color depth)
- Changed min_value/max_value from Some(ParameterValue::Integer

- Created COMMANDS_DOCUMENTATION.md with detailed documentation for all Tauri commands
- Documented node operations (create/delete/connect/disconnect/execute nodes, get results/graph info)
- Documented timeline operations (playback control, seek, clip management, track management)
- Documented preview operations (playback control, frame retrieval, settings, cache management, performance stats, frame export)
- Documented editing operations (project management, media import/info

…n CharacterAnimation

- Extract keyframe values before updating current_value to avoid multiple clones
- Store cloned value in local variable and reuse for both current_value assignment and return
- Clone animation_type when inserting into HashMap and during animation cloning
- Add comment explaining keyframe extraction to prevent borrowing conflicts